﻿#region [ Modification History ]
/*
 * 06/07/2013 Denis Kholine
 *  Add comments and license
 */
#endregion

#region  [ UIUC NCSA Open Source License ]
/*****************************************************************************\
 *             University of Illinois/NCSA Open Source License
 *
 * 
 *      Copyright © 2012,2013, The Board of Trustees of the University of Illinois. All rights reserved.
 *
 *      Developed by: Rakesh Bobba, Derek Dagit, Erich Heine, Denis Kholine,
 *                    Klara Nahrstedt, David Rodgers,   William H. Sanders, Tim Yardley
 *
 *      Information Trust Institute/Coordinated Science Laboratory
 * 
 *      University of Illinois
 *      
 *      The Board of Trustees of the University of Illinois
 *      109 Coble Hall
 *      801 South Wright Street
 *      Champaign, IL 61820-6242
 *
 *      http://www.iti.illinois.edu / http://csl.illinois.edu
 * 
 *      Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
 *      associated documentation files (the “Software”), to deal with the Software without restriction, 
 *      including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
 *      and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
 *      subject to the following conditions:
 *
 *      Redistributions of source code must retain the above copyright notice, this list of conditions and the
 *      following disclaimers.
 *      
 *      Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
 *      the following disclaimers in the documentation and/or other materials provided with the distribution.
 *
 *      Neither the names of Information Trust institute, Coordinated Science Laboratory, University of Illinois,
 *      The Board of Trustees of the University of Illinois nor the names of its contributors may be used to 
 *      endorse or promote products derived from this Software without specific prior written permission.
 *      
 *      THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 *      LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN
 *      NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 *      WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
 *      SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE.
 *      
 \*****************************************************************************/
#endregion

#region [ Using ]
using GSF;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SIEGate.Core;
using SIEGate.Core.Fakes;
using SIEGate.Core.Notifications;
using SIEGate.Core.Measurements;
using SIEGate.Core.Logging;
using SIEGate.Core.Legacy;
using SIEGate.Core.MessageBusses;
using GSF.TimeSeries.Transport;
using Microsoft.VisualStudio.TestTools.UnitTesting;
#endregion

namespace SIEGateCoreTest
{
    /// <summary>
    /// A AdapterBase prototype test class 
    /// NOTE: cast as following
    /// </summary>
    [TestClass]
    public class AdapterBaseTests
    {
        #region [ Members ]
        private StubIAdapterInfo info1;
        private StubIAdapterInfo info2;
        private StubAdapterBase target1;
        private StubAdapterBase target2;
        private MockAdapter adapter;
        private IAdapterInfo info;
        private IAdapterInfo info3;
        private ISet<Guid> incoming;
        private ISet<Guid> outgoing;
        private ISet<Guid> incoming1;
        private ISet<Guid> outgoing1;
        private MockMeasurement measurement;
        #endregion

        #region [ Methods ]
        /// <summary>
        /// A test for link with Microsoft stubs
        /// TODO: test fail due to name cast in AdapterInfoBase constructor
        /// </summary>
        [TestMethod]
        [TestCategory("AdapterBase")]
        public void linkOverStubTest()
        {
            info1 = new StubIAdapterInfo();
            info2 = new StubIAdapterInfo(); 
            
            target1 = new StubAdapterBase(info1);
            target2 = new StubAdapterBase(info2);

            target1.link(target2);
        }

        /// <summary>
        /// A test for link method 
        /// </summary>
        [TestMethod]
        [TestCategory("AdapterBase")]
        public void linkTest()
        {
            incoming = new HashSet<Guid>();
            outgoing = new HashSet<Guid>();
            outgoing1 = new HashSet<Guid>();

            incoming.Add(Guid.NewGuid());
            outgoing.Add(Guid.NewGuid());

            incoming1 = outgoing;
            outgoing1.Add(Guid.NewGuid());


            info = new MockAdapter.MockAdapterInfo(incoming,outgoing);
            MockAdapter adapter = new MockAdapter(info);

            info3 = new MockAdapter.MockAdapterInfo(incoming1, outgoing1);
            MockAdapter adapter1 = new MockAdapter(info3);

            bool expected = true;
            bool actual = false;
            try
            {
                adapter.link(adapter1);
                actual = true;
            }
            catch
            {
                actual = false;
            }
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        /// A test for IncomingStreamIDs method 
        /// </summary>
        [TestMethod]
        [TestCategory("AdapterBase")]
        public void IncomingStreamIDsTest()
        {

            incoming = new HashSet<Guid>();
            outgoing = new HashSet<Guid>(); 

            incoming.Add(Guid.NewGuid());
            outgoing.Add(Guid.NewGuid());
             


            info = new MockAdapter.MockAdapterInfo(incoming, outgoing);
            MockAdapter adapter = new MockAdapter(info); 

            bool expected = true;
            bool actual = false;

            actual = (adapter.IncomingStreamIDs == incoming); 
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        /// A test for OutgoingStreamIDs method 
        /// </summary>
        [TestMethod]
        [TestCategory("AdapterBase")]
        public void OutgoingStreamIDsTest()
        {

            incoming = new HashSet<Guid>();
            outgoing = new HashSet<Guid>();

            incoming.Add(Guid.NewGuid());
            outgoing.Add(Guid.NewGuid());



            info = new MockAdapter.MockAdapterInfo(incoming, outgoing);
            MockAdapter adapter = new MockAdapter(info);

            bool expected = true;
            bool actual = false;

            actual = (adapter.OutgoingStreamIDs == outgoing);
            Assert.AreEqual(expected, actual);

        }

        public void OnEmit(IMeasurement measurement)
        {

        }

         
        /// <summary>
        /// ID test
        /// </summary>
        [TestMethod]
        [TestCategory("AdapterBase")]
        public void IDTest()
        {
            incoming = new HashSet<Guid>();
            outgoing = new HashSet<Guid>();

            incoming.Add(Guid.NewGuid());
            outgoing.Add(Guid.NewGuid());

            info = new MockAdapter.MockAdapterInfo(incoming, outgoing);
            info.ID = 10;
            adapter = new MockAdapter(info); 

            bool expected = true;
            bool actual = (adapter.Info.ID == info.ID);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        /// A Collect test
        /// </summary>
        [TestMethod]
        [TestCategory("AdapterBase")]
        public void CollectTest()
        {
            incoming = new HashSet<Guid>();
            outgoing = new HashSet<Guid>();

            incoming.Add(Guid.NewGuid());
            outgoing.Add(Guid.NewGuid());

            info = new MockAdapter.MockAdapterInfo(incoming,outgoing);
            info.ID = 10;
            adapter = new MockAdapter(info);
            measurement = new MockMeasurement(incoming.Last());
            List<MockMeasurement> measurements = new List<MockMeasurement>();
            measurements.Add(measurement);
            adapter.Collect(measurements.ToArray());

            bool expected = true;
            bool actual = (adapter.HandledMeasurement == measurement);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        /// A test for OnEmit method
        /// </summary>
        [TestMethod]
        [TestCategory("AdapterBase")]
        public void OnEmitTest()
        {
            incoming = new HashSet<Guid>();
            outgoing = new HashSet<Guid>();

            incoming.Add(Guid.NewGuid());
            outgoing.Add(Guid.NewGuid());

            info = new MockAdapter.MockAdapterInfo(incoming,outgoing);

            adapter = new MockAdapter(info);

            measurement = new MockMeasurement();

            MockMeasurement[] measurements = new MockMeasurement[2];

            measurements[0] = measurement;
            measurements[1] = measurement;

            adapter.OnEmit(measurements);

            bool expected = true;
            bool actual = (adapter.Measurements == measurements);
            Assert.AreEqual(expected, actual);

            
        }

        #endregion
    }
}
